home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / umich / tex / tex29 / sttexsrc.zoo / src / tokenstack.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-03-13  |  9.4 KB  |  394 lines
  1.  
  2. /*
  3.  * @(#)tokenstack.c 2.5 EPA
  4.  *
  5.  * Copyright 1987,1988 Pat J Monardo
  6.  *
  7.  * Redistribution of this file is permitted through
  8.  * the specifications in the file COPYING.
  9.  *
  10.  * 
  11.  */
  12.  
  13. #include "tex.h"
  14. #include "box.h"
  15. #include "def.h"
  16. #include "token.h"
  17. #include "tokenlists.h"
  18. #include "tokenstack.h"
  19.  
  20. input   cur_input;
  21. input   input_stack[STACK_SIZE];
  22. ptr     input_ptr;
  23. ptr     max_in_stack;
  24.  
  25. alpha_file  input_file[MAX_IN_OPEN];
  26.  
  27. val     line;
  28. val     line_stack[MAX_IN_OPEN];
  29. ptr     in_open;
  30.  
  31. ptr     param_stack[PARAM_SIZE];
  32. ptr     param_ptr;
  33. ptr     max_param_stack;
  34.  
  35. val     align_state = 1000000;
  36. ptr     base_ptr;
  37. ptr     def_ref;
  38. ptr     warning_index;
  39. int     scanner_status;
  40.  
  41. push_input()
  42. {
  43.     if (input_ptr > max_in_stack) {
  44.         max_in_stack = input_ptr;
  45.         if (input_ptr == STACK_SIZE)
  46.             overflow("input stack size", STACK_SIZE);
  47.     }
  48.     input_stack[input_ptr] = cur_input;
  49.     incr(input_ptr);
  50. }
  51.  
  52. pop_input()
  53. {
  54.     decr(input_ptr);
  55.     cur_input = input_stack[input_ptr];
  56. }
  57.  
  58. begin_token_list (p, t)
  59.     ptr     p;
  60.     qword   t;
  61. {
  62.     push_input();
  63.     state = TOKEN_LIST;
  64.     start = p;
  65.     token_type = t;
  66.     if (t >= MACRO) {
  67.         add_token_ref(p);
  68.         if (t == MACRO) {
  69.             param_start = param_ptr;
  70.         } else {
  71.             loc = token_link(p);
  72.             if (tracing_macros > 1) {
  73.                 begin_diagnostic();
  74.                 print_nl("");
  75.                 switch (t)
  76.                 {
  77.                 case MARK_TEXT:
  78.                     print_esc("mark");
  79.                     break;
  80.  
  81.                 case WRITE_TEXT:
  82.                     print_esc("write");
  83.                     break;
  84.  
  85.                 default:
  86.                     print_cmd_chr(
  87.                         ASSIGN_TOKS,
  88.                         t - OUTPUT_TEXT + OUTPUT_ROUTINE_LOC
  89.                     );
  90.                     break;
  91.                 }
  92.                 print("->");
  93.                 token_show(p);
  94.                 end_diagnostic(FALSE);
  95.             }
  96.         }
  97.     } else {
  98.         loc = p;
  99.     }
  100. }
  101.  
  102. end_token_list ()
  103. {
  104.     if (token_type >= BACKED_UP) {
  105.         if (token_type <= INSERTED) {
  106.             flush_list(start);
  107.         } else {
  108.             delete_token_ref(start);
  109.             if (token_type == MACRO) {
  110.                 while (param_ptr > param_start) {
  111.                     decr(param_ptr);
  112.                     flush_list(param_stack[param_ptr]);
  113.                 }
  114.             }
  115.         }
  116.     } else if (token_type == U_TEMPLATE)
  117.         align_state = 0;
  118.     pop_input();
  119.     check_interrupt();
  120. }
  121.  
  122. back_input ()
  123. {
  124.     ptr     p;
  125.  
  126.     while (state == TOKEN_LIST && loc == NULL)
  127.         end_token_list();
  128.     p = new_token();
  129.     token(p) = cur_tok;
  130.     if (cur_tok < RIGHT_BRACE_LIMIT)
  131.         if (cur_tok < LEFT_BRACE_LIMIT)
  132.             decr(align_state);
  133.         else incr(align_state);
  134.     push_input();
  135.     state = TOKEN_LIST;
  136.     start = p;
  137.     token_type = BACKED_UP;
  138.     loc = p;
  139. }
  140.  
  141. back_error ()
  142. {
  143.     OK_to_interrupt = FALSE;
  144.     back_input();
  145.     OK_to_interrupt = TRUE;
  146.     error();
  147. }
  148.  
  149. ins_error ()
  150. {
  151.     OK_to_interrupt = FALSE;
  152.     back_input();
  153.     token_type = INSERTED; 
  154.     OK_to_interrupt = TRUE;
  155.     error();
  156. }
  157.  
  158. clear_for_error_prompt ()
  159. {
  160.     while (state != TOKEN_LIST &&
  161.         terminal_input &&
  162.         input_ptr > 0 &&
  163.         loc > limit) {
  164.         end_file_reading();
  165.     }
  166.     print_ln();
  167.     clear_terminal();
  168. }
  169.  
  170. begin_file_reading ()
  171. {
  172.     if (in_open == MAX_IN_OPEN)
  173.         overflow("text input levels",  MAX_IN_OPEN);
  174.     if (first == BUF_SIZE)
  175.         overflow("buffer_size", BUF_SIZE);
  176.     incr(in_open);
  177.     push_input();
  178.     index = in_open;
  179.     line_stack[index] = line;
  180.     start = first;
  181.     state = MID_LINE;
  182.     name = 0;
  183. }
  184.  
  185. end_file_reading ()
  186. {
  187.     first = start;
  188.     line = line_stack[index];
  189.     if (name > 17) a_close(cur_file);
  190.     pop_input();
  191.     decr(in_open);
  192. }
  193.  
  194. runaway ()
  195. {
  196.     ptr     p;
  197.  
  198.     if (scanner_status > SKIPPING) {
  199.         print_nl("Runaway ");
  200.         switch (scanner_status) 
  201.         {
  202.         case DEFINING:
  203.             print("definition");
  204.             p = def_ref;
  205.             break;
  206.  
  207.         case MATCHING:
  208.             print("argument");
  209.             p = temp_toks;
  210.             break;
  211.  
  212.         case ALIGNING:
  213.             print("preamble");
  214.             p = align_tokens;
  215.             break;
  216.  
  217.         case ABSORBING:
  218.             print("text");
  219.             p = def_ref;
  220.             break;
  221.         }
  222.         print_char('?');
  223.         print_ln();
  224.         show_token_list(token_link(p), NULL, (val) ERROR_LINE - 10);
  225.     }
  226. }
  227.  
  228. #define begin_pseudoprint() \
  229.     {l = tally; \
  230.     tally = 0; \
  231.     selector = PSEUDO; \
  232.     trick_count = 1000000;}
  233.  
  234. show_context ()
  235. {
  236.     int     i;
  237.     int     j;
  238.     int     k;
  239.     val     l;
  240.     int     m;
  241.     int     n;
  242.     int     p;
  243.     int     q;
  244.     int     old_setting;
  245.  
  246.     base_ptr = input_ptr;
  247.     input_stack[base_ptr] = cur_input;
  248.     loop {
  249.         cur_input = input_stack[base_ptr];
  250.         if (base_ptr == input_ptr ||
  251.             state != TOKEN_LIST ||
  252.             token_type != BACKED_UP ||
  253.             loc != NULL) {
  254.             tally = 0;
  255.             old_setting = selector;
  256.             if (state != TOKEN_LIST) {
  257.                 if (name <= 17) {
  258.                     if (terminal_input) {
  259.                         if (base_ptr == 0)
  260.                             print_nl("<*>");
  261.                         else print_nl("<insert> ");
  262.                     } else {
  263.                         print_nl("<read ");
  264.                         if (name == 17)
  265.                             print_char('*');
  266.                         else print_int(name - 1);
  267.                         print_char('>');
  268.                     }
  269.                 } else {
  270.                     print_nl("l.");
  271.                     print_val(line);
  272.                 }
  273.                 print_char(' ');
  274.                 begin_pseudoprint();
  275.                 if (buffer[limit] == end_line_char)
  276.                     j = limit;
  277.                 else j = limit + 1;
  278.                 if (j > 0) {
  279.                     for (i = start; i < j; incr(i)) {
  280.                         if (i == loc)
  281.                             set_trick_count();
  282.                         print_str(buffer[i]);
  283.                     }
  284.                 }
  285.             } else {
  286.                 switch (token_type)
  287.                 {
  288.                 case PARAMETER:
  289.                     print_nl("<argument> ");
  290.                     break;
  291.  
  292.                 case U_TEMPLATE:
  293.                 case V_TEMPLATE:
  294.                     print_nl("<template> ");
  295.                     break;
  296.  
  297.                 case BACKED_UP:
  298.                     if (loc == NULL)
  299.                         print_nl("<recently read> "); 
  300.                     else  print_nl("<to be read again> ");
  301.                     break;
  302.  
  303.                 case INSERTED:
  304.                     print_nl("<inserted text> ");
  305.                     break;
  306.  
  307.                 case MACRO:
  308.                     print_ln();
  309.                     print_cs(name);
  310.                     break;
  311.  
  312.                 case OUTPUT_TEXT:
  313.                     print_nl("<output> ");
  314.                     break;
  315.  
  316.                 case EVERY_PAR_TEXT:
  317.                     print_nl("<everypar> ");
  318.                     break;
  319.  
  320.                 case EVERY_MATH_TEXT:
  321.                     print_nl("<everymath> ");
  322.                     break;
  323.  
  324.                 case EVERY_DISPLAY_TEXT:
  325.                     print_nl("<everydisplay> ");
  326.                     break;
  327.  
  328.                 case EVERY_HBOX_TEXT:
  329.                     print_nl("<everyhbox> ");
  330.                     break;
  331.  
  332.                 case EVERY_VBOX_TEXT:
  333.                     print_nl("<everyvbox> ");
  334.                     break;
  335.  
  336.                 case EVERY_JOB_TEXT:
  337.                     print_nl("<everyjob >");
  338.                     break;
  339.  
  340.                 case EVERY_CR_TEXT:
  341.                     print_nl("<everycr> ");
  342.                     break;
  343.  
  344.                 case MARK_TEXT:
  345.                     print_nl("<mark> ");
  346.                     break;
  347.  
  348.                 case WRITE_TEXT:
  349.                     print_nl("<write> ");
  350.                     break;
  351.  
  352.                 default:
  353.                     print_nl("? ");
  354.                     break;
  355.                 }
  356.                 begin_pseudoprint();
  357.                 if (token_type < MACRO)
  358.                     show_token_list(start, loc, 100000);
  359.                 else show_token_list(token_link(start), loc, 100000);
  360.             }
  361.             selector = old_setting;
  362.             if (trick_count == 1000000)
  363.                 set_trick_count();
  364.             if (tally < trick_count)
  365.                 m = tally - first_count;
  366.             else m = trick_count - first_count;
  367.             if (l + first_count <= HALF_ERROR_LINE) {
  368.                 p = 0;
  369.                 n = l + first_count;
  370.             } else {
  371.                 print("...");
  372.                 p = l + first_count - HALF_ERROR_LINE + 3;
  373.                 n = HALF_ERROR_LINE;
  374.             }
  375.             for (q = p; q < first_count; incr(q))
  376.                 print_char(trick_buf[q % ERROR_LINE]);
  377.             print_ln();
  378.             for (q = 1; q <= n; incr(q))
  379.                 print_char(' ');
  380.             if (m + n <= ERROR_LINE)
  381.                 p = first_count + m;
  382.             else p = first_count + ERROR_LINE - n - 3;
  383.             for (q = first_count; q < p; q++)
  384.                 print_char(trick_buf[q % ERROR_LINE]);
  385.             if (m + n > ERROR_LINE)
  386.                 print("...");
  387.         }
  388.         if (state != TOKEN_LIST && name > 17 || base_ptr == 0)
  389.             break;
  390.         decr(base_ptr);
  391.     }
  392.     cur_input = input_stack[input_ptr];
  393. }
  394.